#include "ImageLoader.h"
#include <QImageReader>
#include <QDebug>
#include <QFileInfo>
#include <QFile>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonArray>
#include <QUuid>
#include "ImageLoader.h"

ImageLoader::ImageLoader() : FileHandler() {}

QImage ImageLoader::loadImage(const QString& filePath) {
    clearErrorMessage(); // 清空上次错误
    QImageReader reader(filePath);
    reader.setAutoDetectImageFormat(true);
    reader.setAutoTransform(false); // 禁用自动变换以避免ICC配置文件错误
    
    // 特别处理TIF格式
    QFileInfo fileInfo(filePath);
    QString format = fileInfo.suffix().toLower();
    if (format == "tif") {
        reader.setFormat("tif");
    }
    
    QImage image = reader.read();
    if (image.isNull()) {
        setErrorMessage(reader.errorString()); // 记录错误信息
        qDebug() << "Failed to load image:" << errorMessage();
    }
    return image;
}

QList<QVariantMap> ImageLoader::loadJsonParams(const QString &filePath) {
    clearErrorMessage();
    QList<QVariantMap> params;
    QFile file(filePath);
    if (!file.open(QIODevice::ReadOnly)) {
        setErrorMessage("无法打开参数文件: " + filePath);
        qWarning() << errorMessage();
        return params;
    }
    
    QByteArray data = file.readAll();
    file.close();
    
    QJsonDocument doc = QJsonDocument::fromJson(data);
    if (doc.isNull() || !doc.isObject()) {
        setErrorMessage("无效的参数文件格式: " + filePath);
        qWarning() << errorMessage();
        return params;
    }
    
    QJsonObject rootObj = doc.object();
    
    // 处理新格式JSON文件（带嵌套结构）
    if (rootObj.contains("processingParameters")) {
        // 只处理新格式JSON数组
        if (rootObj["processingParameters"].isArray()) {
            QJsonArray processingParamsArray = rootObj["processingParameters"].toArray();
            
            // 遍历所有处理参数，按处理顺序加载
            for (const QJsonValue &value : processingParamsArray) {
                if (value.isObject()) {
                    QVariantMap param = value.toVariant().toMap();
                    params.append(param);
                }
            }
        } else {
            setErrorMessage("无效的处理参数格式，应为JSON数组: " + filePath);
            qWarning() << errorMessage();
        }
    }
    return params;
}

/**
 * @brief 查找处理后图像文件
 * @param originalFilePath 原始图像文件路径
 * @return 处理后图像文件路径，如果不存在则返回空字符串
 */
QString ImageLoader::findProcessedImageFile(const QString &originalFilePath) {
    // 查找名称中带有处理标记的文件
    QFileInfo originalInfo(originalFilePath);
    QString baseName = originalInfo.baseName();
    QString dirPath = originalInfo.path();
    QString extension = originalInfo.suffix();
    
    // 检查常见的处理后缀格式
    QStringList processedSuffixes = {"_processed", "_edited", "_result"};
    for (const QString &suffix : processedSuffixes) {
        QString processedFileName = dirPath + "/" + baseName + suffix + "." + extension;
        if (fileExists(processedFileName)) {
            return processedFileName;
        }
    }
    
    // 检查目录中是否有相同基础名称但标记了处理的文件
    QDir dir(dirPath);
    QStringList filters;
    filters << baseName + "_*" + "." + extension;
    QStringList files = dir.entryList(filters, QDir::Files);
    for (const QString &file : files) {
        QString fullPath = dirPath + "/" + file;
        if (fullPath != originalFilePath) {
            // 简单检查文件名中是否包含处理相关关键词
            QString fileName = QFileInfo(file).fileName();
            if (fileName.contains("processed", Qt::CaseInsensitive) || 
                fileName.contains("edited", Qt::CaseInsensitive) ||
                fileName.contains("result", Qt::CaseInsensitive)) {
                return fullPath;
            }
        }
    }
    
    return QString();
}

/**
 * @brief 查找处理参数文件
 * @param originalFilePath 原始图像文件路径
 * @return 参数文件路径，如果不存在则返回空字符串
 */
QString ImageLoader::findProcessingParamsFile(const QString &originalFilePath) {
    QFileInfo originalInfo(originalFilePath);
    QString dirPath = originalInfo.path();
    QString baseName = originalInfo.baseName();
    
    // 检查常见的参数文件格式
    QStringList paramFilePatterns = {
        baseName + "_params.json",
        baseName + "_settings.json",
        baseName + "_config.json"
    };
    
    for (const QString &pattern : paramFilePatterns) {
        QString fullPath = dirPath + "/" + pattern;
        if (fileExists(fullPath)) {
            return fullPath;
        }
    }
    
    return QString();
}

/**
 * @brief 简化的加载接口：直接传入路径并返回完整的ImageCacheItem
 * @param originalImagePath 原始图像文件路径
 * @return 完整的ImageCacheItem对象，如果加载失败则返回空图像的对象
 */
ImageCacheItem ImageLoader::loadImageCacheItem(const QString &originalImagePath) {
    clearErrorMessage();
    ImageCacheItem cacheItem;
    
    // 检查文件是否存在
    if (!fileExists(originalImagePath)) {
        setErrorMessage("原始图像文件不存在: " + originalImagePath);
        qWarning() << errorMessage();
        return cacheItem; // 返回空的缓存项
    }
    
    // 初始化缓存项基本信息
    cacheItem.originalFilePath = originalImagePath;
    cacheItem.processedFilePath = findProcessedImageFile(originalImagePath);
    cacheItem.paramsFilePath = findProcessingParamsFile(originalImagePath);
    
    // 初始化坐标轴参数为默认值
    cacheItem.axisParams.lengthRatio = 1.0;  // 默认比例为1
    cacheItem.axisParams.timeRatio = 1.0;
    cacheItem.axisParams.wavelengthRatio = 1.0;
    cacheItem.axisParams.lengthUnit = "mm";
    cacheItem.axisParams.timeUnit = "s";
    cacheItem.axisParams.wavelengthUnit = "nm";
    cacheItem.axisParams.xAxisUnit = 0;  // 默认像素单位
    cacheItem.axisParams.yAxisUnit = 0;  // 默认像素单位
    
    cacheItem.hasProcessedImage = false;
    
    // 加载原始图像
    cacheItem.originalImage = loadImage(originalImagePath);
    if (cacheItem.originalImage.isNull()) {
        qWarning() << "加载原始图像失败: " << errorMessage();
        return cacheItem; // 返回加载失败的缓存项
    }
    
    // 加载处理后图像（如果存在）
    if (!cacheItem.processedFilePath.isEmpty() && fileExists(cacheItem.processedFilePath)) {
        cacheItem.processedImage = loadImage(cacheItem.processedFilePath);
        if (!cacheItem.processedImage.isNull()) {
            cacheItem.hasProcessedImage = true;
        } else {
            qWarning() << "加载处理后图像失败: " << errorMessage();
            cacheItem.processedFilePath.clear();
        }
    }
    
    // 加载处理参数（如果存在）
    if (!cacheItem.paramsFilePath.isEmpty() && fileExists(cacheItem.paramsFilePath)) {
        cacheItem.processingParams = loadJsonParams(cacheItem.paramsFilePath);
    }
    
    return cacheItem;
}
